js_parser: fold +, - and ~ of a constant-folded string; stop folding non-ascii strings to NaN - #39072

Problem

• With minify: { syntax: true }, x = +("1" + "2") is printed as x = +"12"; transpiling that output again gives x = 12. Same for -("1" + "2") (-"12", then -12) and ~("1" + "2") (~"12", then -13). A transform(transform(x)) === transform(x) check flags it.
• The same thing happens without minify inside enums, where initializers are always folded: enum E { A = "1" + "2", B = +("3" + "4"), C = -A } emits E[E["B"] = +"34"] = "B" and E[E["C"] = -"12"] = "C", so B and C are not numeric constants and their uses are not inlined. esbuild emits 34 and -12.
• Cause: "1" + "2" is folded into a rope (see Background), and ExprData::to_number (src/ast/expr.rs) returned None as soon as the string had a next segment, in both its EString arm and its EInlinedEnum arm. The +/- folds and the ~ fold in e_unary (src/js_parser/visit/visit_expr.rs) therefore skipped ropes; the printer flattens the rope, so the second pass saw a plain literal and folded it.
• Second symptom in the same function: string_to_equivalent_number_value folded every UTF-8 string containing non-ascii bytes to NaN. Non-ascii source literals are stored as UTF-16 and were never folded, but the strings bun injects as UTF-8 (--define values, inlined process.env) are: with --define 'X="\u00a01"' (U+00A0 is whitespace to StringToNumber, so the value is 1), +X became NaN and, under minify, ~X became -1 (the JS values are 1 and -2). Flattening ropes on its own would have extended this to +(X + "1"), which is left unfolded today.

Fix

• to_number takes the arena and flattens a rope before converting it; str.resolve_rope_if_needed(bump) is the fixing line. The EInlinedEnum arm recurses into the inlined value instead of carrying a copy of the string arm; an inlined enum value is only ever an ENumber or a copy of the member's EString (the EnumNumber / EnumString arms in p.rs and fold.rs), so the arm folds what it folded before, plus ropes.
• string_to_equivalent_number_value returns None for a non-ascii string instead of NaN; return None is the fixing line. JSC__jsToNumber reads latin1, so only ascii bytes can be handed to it as-is; declining leaves the expression unfolded, which is what UTF-16 literals already get.
• Why this is right: flattening does not change the string's value, so a rope folds to exactly what the same characters in one literal already folded to. Every ascii operand that folded before folds to the same number; the only operands that stop folding are non-ascii UTF-8 strings, whose folded value was a guess. Flattening rewrites the root node's data/next only and does not touch the linked segments, which is the in-place flattening Data::eql and extract_string_values in the same file already perform on these nodes, inlined enum copies included.
• Matches esbuild, whose string folding produces one flat string, so +("1" + "2") and the enum members above fold there.
• Callers: SideEffects::to_number (scan_side_effects.rs) takes the arena too and its three uses in e_unary pass p.arena; there are no other callers. (js_parser: fold the unary produced by distributing it over a comma operand #39049 reshuffles the same three lines in e_unary; whichever lands second has a one-line conflict per call.)
• Tests: test/bundler/transpiler/transpiler.test.js ("simplification": the rope folds and their fixed point, the enum cases, the define cases) and test/bundler/bundler_minify.test.ts (minify/ConstantFoldingUnaryOnFoldedString, minify/ConstantFoldingUnaryPlusNonAsciiDefine, through bun build). All five fail on bun 1.4.0 (+"12", E[E["B"] = +"34"], x = NaN, E.B + E.C + E.D left as is) and pass with this change.
• Also ran in full with the debug build: transpiler.test.js, bundler_minify.test.ts, bundler_string.test.ts, bundler_edgecase.test.ts, bundler_regressions.test.ts, transpiler_constant_fold_eqeq.test.ts, esbuild/ts.test.ts, esbuild/dce.test.ts, esbuild/default.test.ts, transpiler/*; and cargo clippy -p bun_ast -p bun_js_parser.

Background

• Rope: when constant folding concatenates two string literals, bun does not build the joined string. It links the right operand onto the left operand's E::String node (next / end / rope_len in src/ast/e.rs, src/ast/fold_string_addition.rs) and the printer walks the chain. resolve_rope_if_needed replaces the root node's bytes with the concatenation (allocated in the parser's arena, hence the new parameter) and clears next. Anything that reads a folded string's bytes has to flatten first or walk the chain; data alone is the first piece.
• Inlined enum: in a TypeScript file, a reference to an enum member with a known value is replaced by an E::InlinedEnum wrapping a copy of the member's number or string (printed as 12 /* A */). Enum initializers are folded whatever the minify settings, so a member defined by concatenation is a rope and each use of it is a rope.
• should_fold_typescript_constant_expressions: the parser flag under which string addition is folded (so ropes exist at all) and under which ~ folds. It is on under minify syntax and always on inside enum bodies. The +x / -x folds run unconditionally, which is why the enum case reproduces without minify.